{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# cnn-mnist\n",
    "使用tensorflow，构造并训练一个神经网络，在测试机上达到超过98%的准确率。 \n",
    "作业详情：https://gitee.com/ai100/quiz-w7-1-cnn-mnist "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\h5py\\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'channels_last'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"A very simple MNIST classifier.\n",
    "See extensive documentation at\n",
    "https://www.tensorflow.org/get_started/mnist/beginners\n",
    "\"\"\"\n",
    "from __future__ import absolute_import\n",
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "\n",
    "import argparse\n",
    "import sys\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "\n",
    "from keras.layers.core import Dense, Flatten, Dropout\n",
    "from keras.layers.convolutional import Conv2D\n",
    "from keras.layers.pooling import MaxPooling2D\n",
    "from keras import initializers\n",
    "from keras.layers import advanced_activations\n",
    "\n",
    "from keras import backend as K\n",
    "\n",
    "K.image_data_format() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们在这里调用系统提供的Mnist数据函数为我们读入数据，如果没有下载的话则进行下载。\n",
    "\n",
    "<font color=#ff0000>**这里将data_dir改为适合你的运行环境的目录**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-698ada706af1>:3: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting /tmp/tensorflow/mnist/input_data\\train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting /tmp/tensorflow/mnist/input_data\\train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting /tmp/tensorflow/mnist/input_data\\t10k-images-idx3-ubyte.gz\n",
      "Extracting /tmp/tensorflow/mnist/input_data\\t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n"
     ]
    }
   ],
   "source": [
    "# Import data\n",
    "data_dir = '/tmp/tensorflow/mnist/input_data'\n",
    "mnist = input_data.read_data_sets(data_dir, one_hot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义输入输出\n",
    "x = tf.placeholder(tf.float32, [None, 784])\n",
    "y_ = tf.placeholder(tf.float32, [None, 10])\n",
    "# 学习速率\n",
    "learning_rate = tf.placeholder(tf.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.name_scope('reshape'):\n",
    "  x_image = tf.reshape(x, [-1, 28, 28, 1])\n",
    "\n",
    "\n",
    "# 二维卷积层，即对图像的空域卷积。\n",
    "# keras.layers.convolutional.Conv2D(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, \n",
    "#                                  dilation_rate=(1, 1), activation=None, use_bias=True, kernel_initializer='glorot_uniform', \n",
    "#                                  bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, \n",
    "#                                  activity_regularizer=None, kernel_constraint=None, bias_constraint=None)\n",
    "# filters：卷积核的数目（即输出的维度）\n",
    "# kernel_size：卷积核的宽度和长度。如为单个整数，则表示在各个空间维度的相同长度。\n",
    "# strides：卷积的步长。如为单个整数，则表示在各个空间维度的相同步长。\n",
    "# activation：激活函数，如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x）\n",
    "# padding：补0策略，为“valid”, “same” 。\n",
    "# use_bias:布尔值，是否使用偏置项\n",
    "# kernel_initializer：权值初始化方法\n",
    "# bias_initializer：权值初始化方法\n",
    "# kernel_regularizer：施加在权重上的正则项\n",
    "# bias_regularizer：施加在偏置向量上的正则项\n",
    "# activity_regularizer：施加在输出上的正则项\n",
    "# kernel_constraints：施加在权重上的约束项\n",
    "# bias_constraints：施加在偏置上的约束项\n",
    "\n",
    "# 卷积层1\n",
    "net = Conv2D(64, kernel_size=[5,5], strides=[1,1], activation='selu', padding='same',\n",
    "             kernel_initializer = 'glorot_normal',  # Glorot正态分布初始化方法，也称作Xavier正态分布初始化\n",
    "             bias_initializer = initializers.Constant(value=0.01), \n",
    "             input_shape=[28,28,1])(x_image)  \n",
    "# 第一层卷积必须显示指定input_shape输入数据形状[高，宽，通道数]\n",
    "# Conv2D 是类方法，第一层时需传递输入数据x_image\n",
    "\n",
    "\n",
    "# 最大值池化层\n",
    "# keras.layers.pooling.MaxPooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=None)\n",
    "# pool_size：代表在两个方向（竖直，水平）上的下采样因子，如取（2，2）将使图片在两个维度上均变为原长的一半。\n",
    "# strides：步长值\n",
    "# border_mode：‘valid’或者‘same’\n",
    "# data_format：“channels_first”或“channels_last”之一，代表图像的通道维的位置。以128x128的RGB图像为例，\n",
    "#              “channels_first”应将数据组织为（3,128,128），而“channels_last”应将数据组织为（128,128,3）。\n",
    "\n",
    "# 池化层1\n",
    "net = MaxPooling2D(pool_size=[2,2])(net) # 池化\n",
    "\n",
    "#卷积层2\n",
    "net = Conv2D(128, kernel_size=[7,7], strides=[1,1],activation='selu', padding='same', \n",
    "             kernel_initializer = 'glorot_normal',  # Glorot正态分布初始化方法，也称作Xavier正态分布初始化\n",
    "             bias_initializer = initializers.Constant(value=0.01))(net)\n",
    "\n",
    "# 池化层2\n",
    "net = MaxPooling2D(pool_size=[2,2])(net)\n",
    "\n",
    "# Dropout层\n",
    "# net = Dropout(0.5)(net)\n",
    "\n",
    "# Flatten层，用来将输入“压平”，即把多维的输入一维化，常用在从卷积层到全连接层的过渡。Flatten不影响batch的大小。\n",
    "net = Flatten()(net) \n",
    "\n",
    "# 全连接层\n",
    "# keras.layers.core.Dense(units, activation=None, use_bias=True, kernel_initializer='glorot_uniform', \n",
    "#                         bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, \n",
    "#                         activity_regularizer=None, kernel_constraint=None, bias_constraint=None)\n",
    "# units：大于0的整数，代表该层的输出维度\n",
    "# activation：激活函数，如果不指定该参数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x）\n",
    "# use_bias: 布尔值，是否使用偏置项\n",
    "# kernel_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器\n",
    "# bias_initializer：偏置向量初始化方法，为预定义初始化方法名的字符串，或用于初始化偏置向量的初始化器\n",
    "# kernel_regularizer：施加在权重上的正则项\n",
    "# bias_regularizer：施加在偏置向量上的正则项\n",
    "# activity_regularizer：施加在输出上的正则项\n",
    "# kernel_constraints：施加在权重上的约束项\n",
    "# bias_constraints：施加在偏置上的约束项\n",
    "\n",
    "# 全连接层1\n",
    "net = Dense(1000, activation='selu')(net) # 全连接层\n",
    "\n",
    "# 全连接层2\n",
    "net = Dense(10,activation='softmax')(net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算交叉熵\n",
    "from keras.objectives import categorical_crossentropy\n",
    "cross_entropy = tf.reduce_mean(categorical_crossentropy(y_, net)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "l2_loss = tf.add_n( [tf.nn.l2_loss(w) for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)] )\n",
    "#惩罚因子，即正则化因子\n",
    "regularization_rate = 1e-4\n",
    "total_loss = cross_entropy + regularization_rate * l2_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(total_loss)\n",
    "sess = tf.Session()\n",
    "K.set_session(sess)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 100, entropy loss: 0.270426, l2_loss: 915.647156, total loss: 0.545120, learning rate: 0.090000, accuracy: 0.990000\n",
      "step 200, entropy loss: 0.121193, l2_loss: 912.535400, total loss: 0.394954, learning rate: 0.090000, accuracy: 0.990000\n",
      "step 300, entropy loss: 0.122665, l2_loss: 908.988342, total loss: 0.395362, learning rate: 0.090000, accuracy: 0.990000\n",
      "step 400, entropy loss: 0.099973, l2_loss: 905.436401, total loss: 0.371604, learning rate: 0.090000, accuracy: 0.980000\n",
      "step 500, entropy loss: 0.053592, l2_loss: 901.458130, total loss: 0.324029, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 500, 训练误差:  0.979873\n",
      "step 500, 测试误差:  0.979200\n",
      "step 600, entropy loss: 0.054085, l2_loss: 897.551514, total loss: 0.323351, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 700, entropy loss: 0.105380, l2_loss: 893.716248, total loss: 0.373495, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 800, entropy loss: 0.090948, l2_loss: 889.541382, total loss: 0.357810, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 900, entropy loss: 0.032229, l2_loss: 885.567200, total loss: 0.297900, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 1000, entropy loss: 0.092903, l2_loss: 881.379517, total loss: 0.357317, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 1000, 训练误差:  0.985836\n",
      "step 1000, 测试误差:  0.982200\n",
      "step 1100, entropy loss: 0.042835, l2_loss: 877.284302, total loss: 0.306020, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 1200, entropy loss: 0.019936, l2_loss: 873.402832, total loss: 0.281957, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 1300, entropy loss: 0.035661, l2_loss: 869.242615, total loss: 0.296434, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 1400, entropy loss: 0.075257, l2_loss: 865.246582, total loss: 0.334831, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 1500, entropy loss: 0.164593, l2_loss: 861.242249, total loss: 0.422966, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 1500, 训练误差:  0.987273\n",
      "step 1500, 测试误差:  0.984300\n",
      "step 1600, entropy loss: 0.027987, l2_loss: 857.157043, total loss: 0.285134, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 1700, entropy loss: 0.047793, l2_loss: 853.179810, total loss: 0.303747, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 1800, entropy loss: 0.011885, l2_loss: 849.203186, total loss: 0.266646, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 1900, entropy loss: 0.015956, l2_loss: 845.153687, total loss: 0.269502, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 2000, entropy loss: 0.017543, l2_loss: 841.082764, total loss: 0.269867, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 2000, 训练误差:  0.988091\n",
      "step 2000, 测试误差:  0.983200\n",
      "step 2100, entropy loss: 0.006561, l2_loss: 837.178528, total loss: 0.257715, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 2200, entropy loss: 0.015035, l2_loss: 833.208252, total loss: 0.264997, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 2300, entropy loss: 0.003792, l2_loss: 829.254150, total loss: 0.252569, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 2400, entropy loss: 0.019016, l2_loss: 825.387939, total loss: 0.266632, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 2500, entropy loss: 0.011541, l2_loss: 821.481384, total loss: 0.257985, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 2500, 训练误差:  0.992800\n",
      "step 2500, 测试误差:  0.987700\n",
      "step 2600, entropy loss: 0.017338, l2_loss: 817.569641, total loss: 0.262609, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 2700, entropy loss: 0.038690, l2_loss: 813.660400, total loss: 0.282789, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 2800, entropy loss: 0.013712, l2_loss: 809.789185, total loss: 0.256649, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 2900, entropy loss: 0.019814, l2_loss: 805.955566, total loss: 0.261601, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 3000, entropy loss: 0.008286, l2_loss: 802.110718, total loss: 0.248919, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 3000, 训练误差:  0.994018\n",
      "step 3000, 测试误差:  0.986700\n",
      "step 3100, entropy loss: 0.004174, l2_loss: 798.234314, total loss: 0.243644, learning rate: 0.090000, accuracy: 1.000000\n",
      "step 3200, entropy loss: 0.022037, l2_loss: 794.575562, total loss: 0.260410, learning rate: 0.084600, accuracy: 1.000000\n",
      "step 3300, entropy loss: 0.052711, l2_loss: 791.246399, total loss: 0.290085, learning rate: 0.079524, accuracy: 1.000000\n",
      "step 3400, entropy loss: 0.024753, l2_loss: 788.052612, total loss: 0.261169, learning rate: 0.074753, accuracy: 1.000000\n",
      "step 3500, entropy loss: 0.012562, l2_loss: 785.018250, total loss: 0.248067, learning rate: 0.070267, accuracy: 1.000000\n",
      "step 3500, 训练误差:  0.996891\n",
      "step 3500, 测试误差:  0.988900\n",
      "step 3600, entropy loss: 0.002438, l2_loss: 782.152832, total loss: 0.237084, learning rate: 0.066051, accuracy: 1.000000\n",
      "step 3700, entropy loss: 0.003501, l2_loss: 779.538208, total loss: 0.237363, learning rate: 0.062088, accuracy: 1.000000\n",
      "step 3800, entropy loss: 0.000969, l2_loss: 777.071289, total loss: 0.234090, learning rate: 0.058363, accuracy: 1.000000\n",
      "step 3900, entropy loss: 0.009578, l2_loss: 774.745850, total loss: 0.242002, learning rate: 0.054861, accuracy: 1.000000\n",
      "step 4000, entropy loss: 0.046485, l2_loss: 772.555481, total loss: 0.278252, learning rate: 0.051570, accuracy: 1.000000\n",
      "step 4000, 训练误差:  0.997618\n",
      "step 4000, 测试误差:  0.989000\n",
      "step 4100, entropy loss: 0.028834, l2_loss: 770.489929, total loss: 0.259981, learning rate: 0.048475, accuracy: 1.000000\n",
      "step 4200, entropy loss: 0.000815, l2_loss: 768.565308, total loss: 0.231384, learning rate: 0.045567, accuracy: 1.000000\n",
      "step 4300, entropy loss: 0.002777, l2_loss: 766.746582, total loss: 0.232801, learning rate: 0.042833, accuracy: 1.000000\n",
      "step 4400, entropy loss: 0.001122, l2_loss: 765.040405, total loss: 0.230634, learning rate: 0.040263, accuracy: 1.000000\n",
      "step 4500, entropy loss: 0.005205, l2_loss: 763.442078, total loss: 0.234238, learning rate: 0.037847, accuracy: 1.000000\n",
      "step 4500, 训练误差:  0.998836\n",
      "step 4500, 测试误差:  0.989600\n",
      "step 4600, entropy loss: 0.002783, l2_loss: 761.929565, total loss: 0.231362, learning rate: 0.035576, accuracy: 1.000000\n",
      "step 4700, entropy loss: 0.021101, l2_loss: 760.521362, total loss: 0.249257, learning rate: 0.033442, accuracy: 1.000000\n",
      "step 4800, entropy loss: 0.001397, l2_loss: 759.191650, total loss: 0.229155, learning rate: 0.031435, accuracy: 1.000000\n",
      "step 4900, entropy loss: 0.003680, l2_loss: 757.949402, total loss: 0.231065, learning rate: 0.029549, accuracy: 1.000000\n",
      "step 5000, entropy loss: 0.016800, l2_loss: 756.773254, total loss: 0.243832, learning rate: 0.027776, accuracy: 1.000000\n",
      "step 5000, 训练误差:  0.999291\n",
      "step 5000, 测试误差:  0.990700\n",
      "step 5100, entropy loss: 0.000269, l2_loss: 755.668091, total loss: 0.226969, learning rate: 0.026110, accuracy: 1.000000\n",
      "step 5200, entropy loss: 0.007685, l2_loss: 754.641724, total loss: 0.234078, learning rate: 0.024543, accuracy: 1.000000\n",
      "step 5300, entropy loss: 0.002665, l2_loss: 753.667725, total loss: 0.228765, learning rate: 0.023070, accuracy: 1.000000\n",
      "step 5400, entropy loss: 0.002718, l2_loss: 752.756653, total loss: 0.228545, learning rate: 0.021686, accuracy: 1.000000\n",
      "step 5500, entropy loss: 0.001318, l2_loss: 751.907837, total loss: 0.226890, learning rate: 0.020385, accuracy: 1.000000\n",
      "step 5500, 训练误差:  0.999545\n",
      "step 5500, 测试误差:  0.990400\n",
      "step 5600, entropy loss: 0.004219, l2_loss: 751.101868, total loss: 0.229550, learning rate: 0.019162, accuracy: 1.000000\n",
      "step 5700, entropy loss: 0.000877, l2_loss: 750.345581, total loss: 0.225981, learning rate: 0.018012, accuracy: 1.000000\n",
      "step 5800, entropy loss: 0.002550, l2_loss: 749.635437, total loss: 0.227441, learning rate: 0.016931, accuracy: 1.000000\n",
      "step 5900, entropy loss: 0.004467, l2_loss: 748.972046, total loss: 0.229158, learning rate: 0.015916, accuracy: 1.000000\n",
      "step 6000, entropy loss: 0.000749, l2_loss: 748.350220, total loss: 0.225254, learning rate: 0.014961, accuracy: 1.000000\n",
      "step 6000, 训练误差:  0.999600\n",
      "step 6000, 测试误差:  0.990900\n",
      "step 6100, entropy loss: 0.004584, l2_loss: 747.765564, total loss: 0.228914, learning rate: 0.014063, accuracy: 1.000000\n",
      "step 6200, entropy loss: 0.007905, l2_loss: 747.213623, total loss: 0.232070, learning rate: 0.013219, accuracy: 1.000000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "step 6300, entropy loss: 0.006394, l2_loss: 746.696838, total loss: 0.230404, learning rate: 0.012426, accuracy: 1.000000\n",
      "step 6400, entropy loss: 0.003344, l2_loss: 746.207947, total loss: 0.227206, learning rate: 0.011681, accuracy: 1.000000\n",
      "step 6500, entropy loss: 0.003506, l2_loss: 745.750916, total loss: 0.227232, learning rate: 0.010980, accuracy: 1.000000\n",
      "step 6500, 训练误差:  0.999636\n",
      "step 6500, 测试误差:  0.990700\n",
      "step 6600, entropy loss: 0.002396, l2_loss: 745.321289, total loss: 0.225993, learning rate: 0.010321, accuracy: 1.000000\n",
      "step 6700, entropy loss: 0.003952, l2_loss: 744.916931, total loss: 0.227427, learning rate: 0.009702, accuracy: 1.000000\n",
      "step 6800, entropy loss: 0.002318, l2_loss: 744.538574, total loss: 0.225680, learning rate: 0.009120, accuracy: 1.000000\n",
      "step 6900, entropy loss: 0.002630, l2_loss: 744.182800, total loss: 0.225885, learning rate: 0.008572, accuracy: 1.000000\n",
      "step 7000, entropy loss: 0.013566, l2_loss: 743.846130, total loss: 0.236720, learning rate: 0.008058, accuracy: 0.990000\n",
      "step 7000, 训练误差:  0.999654\n",
      "step 7000, 测试误差:  0.990800\n",
      "step 7100, entropy loss: 0.004205, l2_loss: 743.532593, total loss: 0.227265, learning rate: 0.007575, accuracy: 1.000000\n",
      "step 7200, entropy loss: 0.004384, l2_loss: 743.235168, total loss: 0.227355, learning rate: 0.007120, accuracy: 1.000000\n",
      "step 7300, entropy loss: 0.003215, l2_loss: 742.956787, total loss: 0.226103, learning rate: 0.006693, accuracy: 1.000000\n",
      "step 7400, entropy loss: 0.003465, l2_loss: 742.696045, total loss: 0.226274, learning rate: 0.006291, accuracy: 1.000000\n",
      "step 7500, entropy loss: 0.004470, l2_loss: 742.451111, total loss: 0.227206, learning rate: 0.005914, accuracy: 1.000000\n",
      "step 7500, 训练误差:  0.999636\n",
      "step 7500, 测试误差:  0.990600\n",
      "step 7600, entropy loss: 0.007062, l2_loss: 742.219910, total loss: 0.229728, learning rate: 0.005559, accuracy: 1.000000\n",
      "step 7700, entropy loss: 0.003073, l2_loss: 742.002441, total loss: 0.225674, learning rate: 0.005225, accuracy: 1.000000\n",
      "step 7800, entropy loss: 0.005143, l2_loss: 741.801453, total loss: 0.227683, learning rate: 0.004912, accuracy: 1.000000\n",
      "step 7900, entropy loss: 0.002283, l2_loss: 741.608826, total loss: 0.224766, learning rate: 0.004617, accuracy: 1.000000\n",
      "step 8000, entropy loss: 0.006281, l2_loss: 741.427856, total loss: 0.228709, learning rate: 0.004340, accuracy: 1.000000\n",
      "step 8000, 训练误差:  0.999600\n",
      "step 8000, 测试误差:  0.991000\n",
      "step 8100, entropy loss: 0.006193, l2_loss: 741.256470, total loss: 0.228570, learning rate: 0.004080, accuracy: 1.000000\n",
      "step 8200, entropy loss: 0.002297, l2_loss: 741.098572, total loss: 0.224627, learning rate: 0.003835, accuracy: 1.000000\n",
      "step 8300, entropy loss: 0.002133, l2_loss: 740.948608, total loss: 0.224418, learning rate: 0.003605, accuracy: 1.000000\n",
      "step 8400, entropy loss: 0.000589, l2_loss: 740.808350, total loss: 0.222832, learning rate: 0.003389, accuracy: 1.000000\n",
      "step 8500, entropy loss: 0.005679, l2_loss: 740.675537, total loss: 0.227882, learning rate: 0.003185, accuracy: 1.000000\n",
      "step 8500, 训练误差:  0.999782\n",
      "step 8500, 测试误差:  0.990900\n",
      "step 8600, entropy loss: 0.002913, l2_loss: 740.552734, total loss: 0.225079, learning rate: 0.002994, accuracy: 1.000000\n",
      "step 8700, entropy loss: 0.005446, l2_loss: 740.435974, total loss: 0.227576, learning rate: 0.002815, accuracy: 1.000000\n",
      "step 8800, entropy loss: 0.001742, l2_loss: 740.326599, total loss: 0.223840, learning rate: 0.002646, accuracy: 1.000000\n",
      "step 8900, entropy loss: 0.021727, l2_loss: 740.223450, total loss: 0.243794, learning rate: 0.002487, accuracy: 0.990000\n",
      "step 9000, entropy loss: 0.001603, l2_loss: 740.126038, total loss: 0.223641, learning rate: 0.002338, accuracy: 1.000000\n",
      "step 9000, 训练误差:  0.999654\n",
      "step 9000, 测试误差:  0.990700\n"
     ]
    }
   ],
   "source": [
    "init_op = tf.global_variables_initializer()\n",
    "sess.run(init_op)\n",
    "batch_size = 100\n",
    "# 学习速率\n",
    "lr = 0.09\n",
    "# 学习速率的衰减率\n",
    "lr_decay = 0.94\n",
    "acc_train_mat = []\n",
    "acc_test_mat = []\n",
    "loss_mat = []\n",
    "l2_loss_mat = []\n",
    "total_loss_mat = []\n",
    "# 训练\n",
    "for step in range(9000):    \n",
    "    batch_xs, batch_ys = mnist.train.next_batch(batch_size)\n",
    "    _, loss, l2_loss_value, total_loss_value = sess.run(\n",
    "               [train_step, cross_entropy, l2_loss, total_loss], \n",
    "               feed_dict={x: batch_xs, y_: batch_ys, learning_rate:lr})\n",
    "    if (step+1) % 100 == 0: \n",
    "        # 测试模型\n",
    "        correct_prediction = tf.equal(tf.argmax(net, 1), tf.argmax(y_, 1))\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n",
    "        print('step %d, entropy loss: %f, l2_loss: %f, total loss: %f, learning rate: %f, accuracy: %f' % \n",
    "                (step+1, loss, l2_loss_value, total_loss_value, lr, sess.run(accuracy, feed_dict={x: batch_xs, y_: batch_ys})))\n",
    "        loss_mat.append(loss)\n",
    "        l2_loss_mat.append(l2_loss_value)\n",
    "        total_loss_mat.append(total_loss_value)\n",
    "        \n",
    "        # 当训练集loss出现波动或趋于平稳，开始学习速率衰减\n",
    "        if step > 3000:\n",
    "            # 衰减学习速率\n",
    "            lr *= lr_decay\n",
    "        \n",
    "        if (step+1) % 500 == 0:\n",
    "            # 计算训练误差，因显卡内存不足，故分批计算求平均值\n",
    "            train_size = mnist.train.images.shape\n",
    "            acc_batch = 0\n",
    "            acc = []\n",
    "            step_time = (int)(train_size[0]/batch_size)\n",
    "            for step_train in range(step_time):\n",
    "                batch_xs, batch_ys = mnist.train.next_batch(batch_size)\n",
    "                acc_batch = sess.run(accuracy, feed_dict={x: batch_xs, y_: batch_ys})\n",
    "                acc.append(acc_batch)\n",
    "            step_acc_train = np.mean(acc)\n",
    "            print('step %d, 训练误差:  %f' % (step+1, step_acc_train))\n",
    "            acc_train_mat.append(step_acc_train)\n",
    "\n",
    "            # 计算测试误差，因显卡内存不足，故分批计算求平均值\n",
    "            test_size = mnist.test.images.shape\n",
    "            acc_batch = 0\n",
    "            acc = []\n",
    "            step_time = (int)(test_size[0]/batch_size)\n",
    "            for step_test in range(step_time):\n",
    "                batch_xs_test, batch_ys_test = mnist.test.next_batch(batch_size)\n",
    "                acc_batch = sess.run(accuracy, feed_dict={x: batch_xs_test, y_: batch_ys_test})\n",
    "                acc.append(acc_batch)\n",
    "            step_acc_test = np.mean(acc)\n",
    "            print('step %d, 测试误差:  %f' % (step+1, step_acc_test))\n",
    "            acc_test_mat.append(step_acc_test)\n",
    "            \n",
    "            if step_acc_test > 0.991:\n",
    "                break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAEKCAYAAAAB0GKPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xd8nNWV8PHfmdGMRr1YcpFsWbaxMW7YWPRQFgglJEAKgWw2C8lmCXnDkrwpG8hmyYbd9N103iRsgJBsWIeWxAQTCA5gui2De5UlGctyUbElq2s05/1jnpFH0kiasfSonu/nMx/NU+dqPJ6je88toqoYY4wxg/GMdgGMMcaMDxYwjDHGxMUChjHGmLhYwDDGGBMXCxjGGGPiYgHDGGNMXCxgGGOMiYsFDGOMMXGxgGGMMSYuSaNdgOGUl5enxcXFo10MY4wZVzZu3FirqvmDnTehAkZxcTGlpaWjXQxjjBlXRGR/POdZk5Qxxpi4WMAwxhgTF9cDhohcLSK7RaRMRO6KcfxWEakRkU3O45NRx7qi9q92u6zGGGP652oOQ0S8wH3Au4EqYIOIrFbVHb1O/Z2q3hHjFq2qutzNMhpjjImP2zWMc4AyVS1X1Q5gFXC9y69pjDHGBW4HjELgQNR2lbOvtw+KyBYReVxEZkXtD4hIqYi8ISI3xHoBEbnNOae0pqZmGItujDEmmtsBQ2Ls673E31NAsaouA54HHo46VqSqJcDfAj8UkXl9bqZ6v6qWqGpJfv6g3YiNMcacIrcDRhUQXWOYCVRHn6Cqdara7mz+N7Ay6li187MceBFY4UYhjza28f3ndrP3yAk3bm+MMROC2wFjAzBfROaIiB+4GejR20lEZkRtXgfsdPbniEiy8zwPuBDonSwfFsdbO/nxX8vYbQHDGGP65WovKVUNisgdwLOAF3hQVbeLyL1AqaquBu4UkeuAIFAP3OpcfgbwCxEJEQ5s347Ru2pYBJK8ALR1hty4vTHGTAiuTw2iqmuANb323RP1/G7g7hjXvQYsdbt8AAF/uKLV2tk1Ei9njDHjko30BgK+cA2j3QKGMcb0ywIGkOIEjNYOCxjGGNMfCxiAz+vB6xHaghYwjDGmPxYwHCk+L60dlvQ2xpj+WMBwBHweq2EYY8wALGA4Aj4vbZbDMMaYflnAcAR8XqthGGPMACxgOMI5DAsYxhjTHwsYjoDPYyO9jTFmABYwHAGf10Z6G2PMACxgOAI+L20WMIwxpl8WMBwpFjCMMWZAFjAclsMwxpiBWcBwpFgOwxhjBmQBw2E5DGOMGZgFDEfA56U9GCIU6r3kuDHGGLCA0a17TYyg5TGMMSYWCxiOFJ+tumeMMQOxgOGI1DAsj2GMMbFZwHCk+J1V9yxgGGNMTBYwHMlJVsMwxpiBuB4wRORqEdktImUicleM47eKSI2IbHIen4w6douI7HUet7hZzkgNwwKGMcbEluTmzUXEC9wHvBuoAjaIyGpV3dHr1N+p6h29rs0FvgaUAApsdK495kZZA0nh2GmjvY0xJja3axjnAGWqWq6qHcAq4Po4r70K+Iuq1jtB4i/A1S6V82QOw9bEMMaYmNwOGIXAgajtKmdfbx8UkS0i8riIzErw2mHR3UvKVt0zxpiY3A4YEmNf76HUTwHFqroMeB54OIFrEZHbRKRUREprampOuaApPqthGGPMQNwOGFXArKjtmUB19AmqWqeq7c7mfwMr473Wuf5+VS1R1ZL8/PxTLmiyM3CvzUZ6G2NMTG4HjA3AfBGZIyJ+4GZgdfQJIjIjavM6YKfz/FngShHJEZEc4EpnnysiNYw2q2EYY0xMrvaSUtWgiNxB+IveCzyoqttF5F6gVFVXA3eKyHVAEKgHbnWurReRfyccdADuVdV6t8pqI72NMWZgrgYMAFVdA6zpte+eqOd3A3f3c+2DwIOuFtDh83pI8oiN9DbGmH7YSO8o4TUxLIdhjDGxWMCIErBV94wxpl8WMKIEfB7aLWAYY0xMFjCi2LrexhjTPwsYUWxdb2OM6Z8FjChWwzDGmP5ZwIiS7PNYLyljjOmHBYwoKdYkZYwx/bKAEcVyGMYY0z8LGFEsh2GMMf2zgBElYDkMY4zplwWMKAG/1TCMMaY/FjCiBJK8dARDhEJ91mkyxphJzwJGlMi63rZMqzHG9GUBI0r3IkqWxzDGmD4sYEQJOMu0Wh7DGGP6soARxVbdM8aY/lnAiBIJGK22rrcxxvRhASNKJIfRbklvY4zpwwJGlJM1DEt6G2NMbxYwoqRYDsMYY/plASOK9ZIyxpj+uR4wRORqEdktImUictcA531IRFRESpztYhFpFZFNzuPnbpfVekkZY0z/kty8uYh4gfuAdwNVwAYRWa2qO3qdlwHcCbzZ6xb7VHW5m2WMZgHDGGP653YN4xygTFXLVbUDWAVcH+O8fwe+C7S5XJ4BdU8NYiO9jTGmD7cDRiFwIGq7ytnXTURWALNU9U8xrp8jIm+LyEsicpGL5QQgkGQ5DGOM6Y+rTVKAxNjXPRWsiHiAHwC3xjjvEFCkqnUishL4g4gsVtXGHi8gchtwG0BRUdGQCpvk9eDzijVJGWNMDG7XMKqAWVHbM4HqqO0MYAnwoohUAucBq0WkRFXbVbUOQFU3AvuABb1fQFXvV9USVS3Jz88fcoEDSbYmhjHGxOJ2wNgAzBeROSLiB24GVkcOqmqDquaparGqFgNvANepaqmI5DtJc0RkLjAfKHe5vAT8XsthGGNMDHEHDBFJc5qQEJEFInKdiPgGukZVg8AdwLPATuBRVd0uIveKyHWDvOTFwBYR2Qw8DtyuqvXxlvdUhZdptRqGMcb0lkgOYx1wkYjkAGuBUuAm4KMDXaSqa4A1vfbd08+5l0Y9fwJ4IoHyDYsUn9cChjHGxJBIk5SoagvwAeAnqvp+YJE7xRo9AZ/lMIwxJpaEAoaInE+4RvG0s8/tXlYjLmA1DGOMiSmRgPE54G7g904eYi7wgjvFGj3hGoYlvY0xpre4awiq+hLwEnSPn6hV1TvdKthoSfF5ONpoNQxjjOktkV5Sj4hIpoikATuA3SLyJfeKNjosh2GMMbEl0iS1yBllfQPhXk9FwMdcKdUosl5SxhgTWyIBw+eMu7gB+KOqdhI1zcdEEfB5bU1vY4yJIZGA8QugEkgD1onIbKBxwCvGoYDPS1vQkt7GGNNb3AFDVX+sqoWq+h4N2w/8jYtlGxUBn4eOYIiu0ISrPBljzJAkkvTOEpHvi0ip8/gvwrWNCSWyrnd70JqljDEmWiJNUg8CJ4APO49G4CE3CjWaIqvujac8RmtHF794aZ/ViowxrkokYMxT1a85q+eVq+rXgbluFWy0RGoY4ymP8dKeo3zrmV1sPdgw2kUxxkxgiQSMVhF5V2RDRC4EWoe/SKMr2eesujeOahgNrZ0AtLQHR7kkxpiJLJG5oD4NPCwiWYRX0qsn9kp541p3DWMcjcVobA0HChtwaIxxUyJTg2wCzhSRTGd7wnWphZM5jHEVMNqcGsY4qhUZY8afQQOGiHy+n/0AqOr3h7lMoyrFHwkY4yeHEWmSshqGMcZN8dQwMlwvxRgSSHJ6SY2jL99GJ2CMp1qRMWb8GTRgOL2hBiUid6vqt4ZepNGV4g8nvcfTl29jWziHYU1Sxhg3JdJLajA3DuO9Rk3yOK5hjKeeXcaY8Wc4A4YM471GTSSH0T6eAkabNUkZY9w3nAFjQgwz7h7pPY6+fLvHYVgNwxjjIqth9BJIiuQwxk8vKRuHYYwZCcMZMB6LtVNErhaR3SJSJiJ39XexiHxIRFRESqL23e1ct1tErhrGsvYryevB55Vx8+XbEQx1l3W8lNkYMz7FMw7jJwzQ3BRZ11tVvxnjWi9wH/BuoArYICKrVXVHr/MygDuBN6P2LQJuBhYDBcDzIrJAVV3/VgyMo1X3Tjj5C7CktzHGXfGMwygdwv3PAcpUtRxARFYB1xNeEzzavwPfBb4Yte96YJWqtgMVIlLm3O/1IZQnLuMpYES61IIFDGOMu+IZh/HwEO5fCByI2q4Czo0+QURWALNU9U8i8sVe177R69rC3i8gIrcBtwEUFRUNoagnhdf1Hh85jEjCG6xJyhjjrrjnkhKRfODLwCIgENmvqpcNdFmMfd3NWyLiAX5A7EkMB7w26vXvB+4HKCkpGZaeWgGfZ9z8tR4ZgzElzT9uymyMGZ8Sma32t8DvgGuB24FbgJpBrqkCZkVtzwSqo7YzgCXAi87cVNOB1SJyXRzXuibF52XP0RN879ldHGvpJMkjfOU9Z3R3uR1LImMwpmUGaLLpzY0xLkqkl9QUVX0A6FTVl1T1E8B5g1yzAZgvInNExE84ib06clBVG1Q1T1WLVbWYcBPUdapa6px3s4gki8gcYD6wPoHynrJZuamU1zTz85fK+dPman79+n7erKgfiZdOWKRL7fSsgDVJGWNclUgNI9JYfkhEriX81/7MgS5Q1aCI3AE8C3iBB1V1u4jcC5Sq6uoBrt0uIo8STpAHgc+MRA8pgB/dvIJvvH8pmYEkWjq6WPb15yitrOeSBfkj8fIJOVnDSGZ9hQUMY4x7EgkY/+EsnvQF4CdAJvC5wS5S1TXAml777unn3Et7bX8D+EYCZRwWXo+QleIDIC05icUFmWyoHJs1jIbWcJNZbpqf1s4uVLV76nljjBlOiTRJHXOakLap6t+o6krCq+5NeCWzc9l04DgdY3Cd78bWTjJTfKT6k+gKKR1dY6+MxpiJIZGA8ZM49004Zxfn0NYZYnt1w2gXpY/GtiCZgaSTKwV2WMAwxrgjnpHe5wMXAPm9Vt/LJJyXmPBWFucAUFp5jBVFOaNcmp4aWzvJSvGR6j85aWIWvlEulTFmIoqnhuEH0gkHl4yoRyPwIfeKNnZMzQhQPCV1TOYxGtvCTVIpTg2jpcO61hpj3BHPSO+XgJdE5Fequt+Z90lVtcn94o0dJcW5/HXX0TGXVG5s7aQgK2VcTstujBlfEslhZIjI28A2YLuIbBSRJS6Va8w5uziH+uYOymubR7soPTS0BslMSepukhovc2AZY8afRALG/cDnVXW2qs4m3L32fneKNfaUFOcCUDrGmqW6m6T8kSYpCxjGGHckEjDSVPWFyIaqvgikDXuJxqi5eWlMSfOzvuLYaBelW1tnFx3BEJmBkzkMm0/KGOOWRAbulYvIvwK/cbb/DqgY/iKNTSJCSXEOpfvHTg0jMso7uoZhOQxjjFsSqWF8AsgHnnQeecSeZXbCOrs4l/11LRxtbBv03Kb2IHVN7a6WJzKPVGYgyWoYxhjXJRIwrlDVO1X1LOfxOcIr6U0a3XmM/YM3S3199XY+8LPXCIWGZcb1mCJrYUR3q7UahjHGLYkEjLvj3DdhLS7IJODz8FYcAWNfTRP761pcHbsRaZLKsiYpY8wIiGek9zXAe4BCEflx1KFMwrPITho+r4fZuWm8U98y6LmHGsLNVn/YVM25c6e4Up7I4kmZAR/JSR5ErEnKGOOeeGoY1YTX9W4DNkY9VgNXuVe0sakgO0B1Q+uA5wS7Qhw9Ec5frNl6yLVJCyPreWemJCEipPi8FjCMMa6JZ6T3ZmCziDyiqp39nSciT6jqB4e1dGNQQXYKm6sGnoSwpqmdrpDy7kXT+MuOI7y4+yhXLp4+7GWJrmEApPq9tFiTlDHGJXHnMAYKFo65QyzLuFCQnUJ9c8eAf8lHmqNuXDmT3DQ/f9zkzsqyja2dJCd5uqcFCfi8tFkNwxjjkkSS3oNxrzvQGFKYnQIwYLPUoePhgDErN5X3LpvB8zuPcKJtsHibuMgo74gUn9eS3sYY1wxnwJgUCiIB4/gAAcMJJgVZKVy/vJD2YIg/bzs87GVpbA2vhRGR6vfa1CDGGNcMZ8AYO1O4uqggOwAMFjDaSPF5yUxJ4qyibIpyU11plupdwwhYDcMY46JTChgikiMiy3rt/vIwlGfMm5YZwCNw8Hj/o70PN7QxIzuAiCAiXL+8gNf21cYcId7ZFWJHdeMplaWxtbM74Q2Q4vfabLXGGNfEHTBE5EURyRSRXGAz8JCIfD9yXFWfc6OAY43P62FaZmDQJqkZWYHu7UtPn0pIidm76g9vH+S9P3mZoycGn26ktwZntb0Ia5IyxrgpkRpGlqo2Ah8AHlLVlcAVg10kIleLyG4RKRORu2Icv11EtorIJhF5RUQWOfuLRaTV2b9JRH6eQFldVZCdMmiT1PTMlO7t6U7wqI0xt9SBY62EFA7UDzy2I5bGtvBaGBEBG4dhjHFRIrPVJonIDODDwL/Ec4GIeIH7CM85VQVsEJHVqroj6rRHVPXnzvnXAd8HrnaO7VPV5QmUcUQUZKewtep4zGORQXuRXAdAXrofgJoTfQNGZN+ROCY0jKaqfZukfNYkZYxxTyI1jHuBZwl/iW8QkbnA3kGuOQcoU9VyVe0AVgHXR5/g1Foi0hgH3XPDo73bYk4sGBm0Nz2qSSo5yUtWim/AgBEZuxGv1s4ugiHtkfS2JiljjJvirmGo6mPAY1Hb5cBgI7sLgQNR21XAub1PEpHPAJ8H/MBlUYfmOMvCNgJfVdWX4y2vmwqzU+gIhqhr7iA/I7nHscgXf0FWSo/9+RnJMZukapx9hweZbqS3k1Ob9x2HMdbWHTfGTAyJJL3nishTIlIjIkdF5I8iMmewy2Ls6/Nnuarep6rzCPe0+qqz+xBQpKorCAeTR0QkM0a5bhORUhEprampiffXGZJIMIiVx4gM2ouuYQDkpyfHrGHUnmINIzK1eXTSO+DMWNvu0txVxpjJLZEmqUeAR4EZQAHh2saqQa6pAmZFbc8kPJlhf1YBNwCoaruq1jnPNwL7gAW9L1DV+1W1RFVL8vPz4/xVhmagwXvRg/ai5WUkd9cmIlS1O4gcTjBgnFxtL2rgns/W9TbGuCeRgCGq+htVDTqP/2HwfMMGYL6IzBERP3Az4VluT95UZH7U5rU4eRERyXeS5jj5kvlAeQLldU1kepCDMQPGyUF70WLVMBpbg3R0hWsDhxNMeveeeBCwNTGMMa5KpJfUC0632FWEA8VNwNPOuAxUtc9KQaoaFJE7CCfLvcCDqrpdRO4FSlV1NXCHiFwBdALHgFucyy8G7hWRINAF3B7rNUZDZkoSaX4v1TEG70UP2ouWn5FMS0cXze1B0pLDb3tNU/j6mTkpHGkMJ9E9nvhyD9HreUek+MP3ta61xhg3JBIwbnJ+fqrX/k8QDiAxZ6tV1TXAml777ol6/tl+rnsCeCKB8o0YEel3LEZ1r0F7EZHkeM2J9u6AEVkzY9nMLNZsbY2ZRO9PJOmd1WvyQbCAYYxxRyLTm88Z4DEppjaPVpCdEnPG2sMNbczolb+AkwEjuqdUpIlqaWF297XxiiS9M6ImH7R1vY0xbkqkl1SqiHxVRO53tueLyHvdK9rYFquGEewKcaSxLXYNI/1kDSPiZMDIAk4mzOPR2NpJqt+Lz3vynzCSw2jpmFQr5xpjRkgiSe+HgA7gAme7CviPYS/ROFGYHaC2qaPHyOqapnZC2rdLLUQ1SUXXMJra8Sd5WDAtHUgs8d3Y1nOUN5ysYdhob2OMGxIJGPNU9buEk9OoaiuTZErzWCJda6PHT/Q3aA8gN82PR/rWMPLTk8lLTybJIwk1STW2Bvv0xLJeUsYYNyUSMDpEJAWnK62IzAP6jkSbJGKNxehv0B6A1yPkpiX3DRgZyXg8wrTMQEIBo6apndw0f499qX4bh2GMcU8iAePfgD8Ds0Tkt8BaJskaGLHEGovR36C9iN7Tg0QCBsCMrEBCo70ra5uZk5fWY1/AekkZY1yUyFxSz4nIRuA8wk1Rn1XVWtdKNsZNywwg0quG0c+gvYj8jJ41jNqmds6anQOEayXb41xIqaG1k7rmDoqn9AwYlsMwxrgpkV5Sa1W1TlWfVtU/qWqtiKx1s3BjmT/Jw9SM5B4Bo79BexHRo72DXc7khU7vqemZAQ41tKI6+GS9lbXNABT3qmH4kzwkecSapIwxrhi0hiEiASAVyBORHE4mujMJzyk1ac3ISukx2ru/QXsR+c58UqpKfXMHqid7T03PCtDWGaKxNUhWqq/fewBU1oUDRu8mKTg5Y60xxgy3eGoYnwI2AgudnxuBUuCPwE/dK9rYV9hrLEZ/g/Yi8tL9dHYpDa2d3aO8T+YwnF5XjYOPxaiobUYEinJT+xwL2LrexhiXDBowVPVHqjoH+Aaw3Hn+EOGJAF93uXxjWkF2gMq6Zj7889f5v7/b1O+gvYjo6UEi4zGiaxgQ3zTnlbXNFGSldCe5o9kiSsYYtyTSS+pDqtooIu8ivOTqr4CfuVKqceKms2dxw4pCEFhfUY/P62H5rOx+z48evBfJZURyGJFAE0/X2oq6lpjNUeA0SVnAMMa4IJHJByPfQtcCP1fVP4rIvw1/kcaP06Zm8P0Pn1xyfLCV7qZG1zB6NUnlZyTjkcFrGKpKRU0T1y2PnT4KWA7DGOOSRGoYB0XkF8CHgTUikpzg9RPeYMui5qeHaxGRgJERSOpuVvJ5PeSlJw+6VOuxlk4a24J9utRGpPqthmGMcUciX/gfJryuxdWqehzIBb7kSqkmqMyUJPxeT7hJqqm9z1TmM7ICHG4cePB8RW3/PaTAekkZY9yTyMC9FuDJqO1DhNfdNnESke7Be5F5pKJNzwp0B4T+9DcGIyJgNQxjjEusSWmE5aX7qW3qoPZErBpGyqA5jMq6ZjwCs3L6dqmF8LreVsMwxrjBAsYI61HDyOhbwzjRFqSpvf/1LCpqm5mZk4o/KfY/XYrfAoYxxh0WMEZYfkYyVfUtnGgPxsxhwMBdayvr+k46GC3FZ+MwjDHusIAxwvLTkznh1CB65zCmZYYDxpF+FlIKd6kdJGD4vXQEQ3SFBp+TyhhjEmEBY4RF1yr6q2H0l8eoaWqnuaOL4imx8xdgM9YaY9xjAWOEDRQwIjWM3muFR1TWtgD995CC6HW9LWAYY4aX6wFDRK4Wkd0iUiYid8U4fruIbBWRTSLyiogsijp2t3PdbhG5yu2yjoS89P4DRsDnZfaUVLZXN8S8tnKQMRjQt4ZxrLmDv+w4MqQyG2MMuBwwRMQL3AdcAywCPhIdEByPqOpSVV0OfBf4vnPtIuBmYDFwNfD/nPuNa5Eg4RGYkpbc5/jK2TmUVh6LuS5GRV0zSR7pXu0vlt7rev/0hTL+8del1Dd3DEfxjTGTmNs1jHOAMlUtV9UOYBVwffQJqhq9zFwazprhznmrVLVdVSuAMud+41qkhpGblozX03cqkbOLc6lr7qCyrqXPscraZoqmpJLk7f+fLVLDaOnoQlVZuzNcuyivaRqO4htjJjG3A0YhcCBqu8rZ14OIfEZE9hGuYdyZyLXjTVpyEml+b5/mqIgSZ8nW0sr6PscqapuZ088cUhHdNYyOLvbVNHcHnvJBRpAbY8xg3A4YsWbj69PWoqr3qeo84MvAVxO5VkRuE5FSESmtqakZUmFHSn5GMnnp/pjH5uWnk5Xio7TyWI/9oZBSWdc8YMIbeuYwIrULj0B5jQUMY8zQJDK9+amoAmZFbc8Eqgc4fxUn19iI61pVvR+4H6CkpGRcDD748tULyU6NHTA8HqFkdg6l+3vWMA4eb6WtMzR4wIjqJbV211HOmJFJR7CLilprkjLGDI3bNYwNwHwRmSMifsJJ7NXRJ4jI/KjNa4G9zvPVwM0ikiwic4D5wHqXyzsirlk6g/PnTen3+MriHPbVNPdIVK/eHI6VF52WN+C9U33hvwEONbSycf8xrjhjKnPz062GYYwZMldrGKoaFJE7CE+L7gUeVNXtInIvUKqqq4E7ROQKoBM4BtziXLtdRB4FdgBB4DOqOikGF5TMzgVg4/5jvHvRNFSVx0oPcO6c3EFrGAF/+G+AP287TFdIufyMaXQEQ7y0u4aukMZMtBtjTDzcbpJCVdcAa3rtuyfq+WcHuPYbhNcSn1SWzczC5xVK99fz7kXTeLOinsq6Fu68fP6g16b6w/+kpfuPkZeezLLCLHYfbqSjK8TBY60UDTBKfLyJdD0ebOEqY8zwsJHeY1DA52VpYRYbncT3o6UHyEhO4polMwa/NmoW28sW5uPxCHPy0gEon2B5jM+u2sQdj7w92sUwZtKwgDFGlRTnsqWqgdqmdtZsPcT7lhd0J7QHkuT14HfGaVx+xjQA5uaHm7EmUh5DVXm1rJaX99bEHORojBl+FjDGqJWzc+joCvHNNTtp6wxxU8mswS9ypPi9+L0e3uUkyKek+ckIJA26mt94cvREO3XNHTS2Bak6NvA66MaY4WEBY4yKDOB78q2DnD4tg2Uzs+K+NiOQxPnzppCWHM5niEi4p9QEapKKnm9re3XjAGcaY4aLBYwxakp6MnOdHlEfPntWQondH928nH+/fkmPfXPz0qgYxSap5vYgP3x+z7CtN77DCRIeod/JGo0xw8sCxhh2zpxc/F4P71+R2IwoK2fn9ukNNTcvjeqGNlo6+l/+1U1Pba7mh8/v5a+7jg7L/XYcaqQoN5X5UzOshmHMCLGAMYZ94crTWfWp88hNiz0qPBFznMR3ZE2NkbZub3jalk0Hjg1yZnx2VDeyaEYmiwsyrYZhzAixgDGG5Wckc1ZRzrDca67TtXY0Et/BrhCv7K0FYPOBoX+5N7UHqaxrYVFBJosKMjnS2E7NifYh37e3H6/dy8OvVQ77fY0ZryxgTBLFeeEmqtGY5nzLwQYa24IUZAXYerCBYFdoSPfbdSjcBLVoRiZLCsOdAdyoZfzmjf389IUyQrY+ujGABYxJI9WfREFWYFRqGOv21CACn7pkHq2dXew5MrSgtcMJGIsLwzUMGP6eUo1tndScCNdcthy0Ji9jwALGpDInP419oxQwls3M5tLT8wHYdOD4kO63o7qRnFQf0zMDZAZ8FOX2v6ztqYoe5Pi8LXFrDGABY1KZm5dORU3TiI6MbmjtZNOB41wyP4+i3FRyUn1DTnzvONTIooLM7q7GSwozh72GEWm6K8gK8PxOCxjGwAhMPmjGjjl5aTS2Balr7iAvPZmN++t5tayOxtZOGlo76egKcfc1ZzA9KzBsr/laWS1hFCZoAAAZFElEQVQhhYsW5CMinDkre0iJ72BXiF2HT3DL+bO79y0uyGLN1sM0tnWSGfANR7Eprwmvn/6x84v5zp93caC+hVm5E2fiRmNOhQWMSSQyp9TqTdW8uKeGdXvCXV1T/V4yAz5qmtrJTvHx9V6D/oZi3d4aMpKTWD4rG4AzZ2bz0p69NLUHSU9O/ONXXttMRzDUnbsAup/vqG7kvLn9rzOSiH01TRTlpnLNkul858+7eH7nET5+4Zxhubcx45U1SU0ika619/5pB1urjnP3NQvZ/vWr2HHv1bzxlct5/4pCfld6oMfCTYMpraznW2t2xuxJpKqs21PLBadNwedMiLi8KBtV2FJ1anmMSK5i0YyTU6UsKYj0lBq+Zqnymmbm5qdTnJfG/Knp/MXyGMZYwJhMZuakcOPKmXzxygW8/OXL+NQl87rnmwK47eK5tHWG+M3r+3tcV3a0iW88vSPmtB7f/fNufrGunN+uf6fPsfLaZg4eb+Wi+fnd+5bPDNc0TrVZakd1I/4kT3dtCcLjVaZmJA9b4rsrpFTUNTPPeY0rnDVJGlo6h+X+xoxXFjAmEY9H+N6NZ3LHZfNjNgctmJbBZQun8vDrld3B4URbJ7f9upT/frmCxzce6HF+2dETrK+sJ83v5TvP7OJQQ89ZYyNNXpcsOBkwctL8zJ6SesqJ7x2HGlk4PaO7xhKxuCCT7QeHp4Zx8FgrHcFQd1C64oxpdIWUF/cMz7QmxoxXFjBMD5+6eC71zR08/lYVqspdT2xlf30LM3NSeOCVCrqimp5WrT9Akkf4n0+eS1dI+ervt3X3wNpa1cDPX9rHvPy0Psni5b0S37sON/Lzl/b1uHcsqto9JUhvSwqzKKtpoq1z6JMb7nNm9Z2Xn95d3rx0P8/vtIBhJjcLGKaHc+bkcuasbH75cjkPvFLB01sP8aWrTueuaxZSWdfCWqeLaXuwiyfequLKxdNYUZTDF65cwNpdR3lqyyGe3nKIG3/xGkkeDz/927P6vMaZM7M53NjG4YY2Xt5bw4d+9jrffmZX9737U93QxrGWzh4J7+h7doWU1/fVDfk92Hc0HDDmOgHD6xEuWziVF3cdpSM4tFHqxoxnFjBMDyLC7RfPZX9dC//x9E6uOGMat100l6sXT6cwO4VfvlwBwLPbj3CspZObzy4C4OMXzuHMWdnc9cQWPvPIWywuyOIPn7mQM2LUBpYXhfMY335mJx9/aAMzc1IoyArw4KsVA5YtElBi9YS6eEE++RnJ/Pr1yiH89mHltc1kp/p6TPp48YJ8TrQH2X34xJDvb8x4ZQHD9HHl4unMzU9jVm4K/3XjmXg8QpLXw8cvLGZ9ZT2bDxxn1fp3mJmT0r2qn9cjfOeDSwH40MqZPPKP55KfkRzz/otmZOLzCn/YVM3Zxbk8evv53HphMW+U1w+YuH56yyFOm5rOgmkZfY75kzx89NwiXtxTQ+UQR7PvO9rU3RwVsawwHOS22cy4ZhKzgGH68HqEx2+/gDV3XkRW6smBcDedPYuM5CTu/dMOXttXx81nz8LjObmw08Lpmbx9z7v5zxvPJDmp//XHAz4vN5bM4iPnFPGrT5xNZsDHTWcXker38uArlTGvOXqijfWV9bxn6Yx+7/u35xaR5BF+3auXV6LKa5u7F6+KmJWbQkYgiW02r5SZxFwPGCJytYjsFpEyEbkrxvHPi8gOEdkiImtFZHbUsS4R2eQ8VrtdVnNSbpqfjF6jpjMCPj5ybhEb9x/D6xFujLHO+ECBIto337+Ub31gaff5WSk+blw5k6c2V3P0RFuf85/ddhhVuHaAgDE1I8B7ls7gsdIDNLef2kJRkUkH5/aqYYgISwqy2GaLNZlJzNWAISJe4D7gGmAR8BERWdTrtLeBElVdBjwOfDfqWKuqLnce17lZVhOfWy8oJslJAk/LHL4pRABuvXAOnaEQ//NG3zEdT2+NNEelx7jypFsuKOZEe5An3z54SmWITDo4Lz+tz7ElhZnsPNRI5xCnZzdmvHK7hnEOUKaq5araAawCro8+QVVfUNXIMnBvADNdLpMZgoLsFH7zD+f2WTN8OMzJS+PyhVP57Rv7e3SPrTnRzvqKcHPUYGubr5iVzdLCLH79WuUpTbIYmXSwdw0Dwl13O4Ih9o3CmiLGjAVuB4xCIHq0V5Wzrz//ADwTtR0QkVIReUNEboh1gYjc5pxTWlNTM/QSm0GdP2/KsE5QGO0TF86hrrmDB1452WPqz9sPExqkOSpCRLjlgmL2Hm3itVPoYruvpgmvRyiKMdHgYqc777ZhGiD44Z+HuxMbM164HTBi/TkY888+Efk7oAT4XtTuIlUtAf4W+KGIzOtzM9X7VbVEVUvy8/N7HzbjzPnzpnDloml879nd/PylfQA8vaWaeflpgzZHRbx32QympPm7r09EeU0zs3NT8Sf1/a8xJy+dFJ93WBLf5TVNrK+sZ/WmgyM63bwxQ+F2wKgCojOjM4Hq3ieJyBXAvwDXqWr34syqWu38LAdeBFa4WVgz+kSE+z56Fu87s4BvP7OLr/1xG+sr6rk2juaoiIDPy20Xz+XlvbWUVtYn9PrhSQf75i8g3HtsUUHmsMxZFZnMsLqhzZq4zLjhdsDYAMwXkTki4gduBnr0dhKRFcAvCAeLo1H7c0Qk2XmeB1wI7HC5vGYM8Hk9/PCm5dx89iwefn1/uDlqWUFC9/jY+bPJS/fzg+f3xH1NZNLBWPmLiCUFmeyobhzyOt/P7ThCgdOs99Ke2gHP/euuI9z3QtmQXs9MLI1tnfzrH7ZxLIGZpYeDqwFDVYPAHcCzwE7gUVXdLiL3ikik19P3gHTgsV7dZ88ASkVkM/AC8G1VtYAxSXg9wrc+sJR/uuw03ndmQdzNURGp/iRuv2Qer5bV8WZ5fLmMqmMtdARDMXtIRSwuzKK5o4vKulMfHHj0RBtvvXOMm88pYm5+WvckjbF0hZR7/rid/3xuN0cb+3Y3NpPTM1sP8Zs39vPUlj4NNq5yfQElVV0DrOm1756o51f0c91rwFJ3S2fGMhHhC1eefsrX/915s/nFunJ+8PweVt12/qDn/+j5vXg9wsrZOf2eE1l7Y1t144A1kYGs3XkUVbhy8TTqmztYteEd2jq7CPj6jmH5y44jVB0LzwL8zLbD3HJB8Sm9pplY1jm10nV7avj784tH7HVtpLeZsAI+L5+5dB5vlNfz2r6Bm32e2lzNk28f5J8uO43TpvadeiRi/rR0/F4P24eQ+H5u+2Fm5aZw+rQMLlmQT1tniA395FoeerWCwuwU5uWnsWbroVN+TTNxBLtCvLw3XCt9fV/diE6IaQHDTGg3n1PE9MwAX/39Nj636m0++XApH3vgTVatf6d7OvXq4638y++3sqIomzv+5rQB7+fzelg4I+OU55Rqag/y6r46rlw0HRHh3Lm5+L2emM1S2w428GZFPbdeUMy1ywpYX1kfcxT8ZKOqbD5wfMh5pPFqc1UDjW1Brl9eQHNHFxv3n9raMqfCAoaZ0AI+L3dds5AT7UE2vnOMqmMtHDzeyl1PbuWG+15l4/56vvDoZoIh5Yc3LSfJO/h/icUFWWw72HhK3WHX7amhIxjiykXTgHCu5ew5Od1NDNEeerWSVL+XD589i2uXzkA1PEXKZPfHTdVcf9+r/OwUuk1PBC/tqcEj8KWrTifJI921jZFgAcNMeDesKGTDv1zBy/98GX/+3MWs/fwl/Ojm5Rw90cYHf/Y6r5fX8W/vW8zsKf0nu6MtKcykobWzO7fQn+MtHXz1D1u583/fZoczB9Vz2w+Tm+bvkSe5eH4+u4+c4HDDydpDzYl2ntpczYdWziQrxceCaenMzU9jzdaeAeOXL5dz/7p9k2YsR2dXiB86Pd9++teyPqs8Tgbr9tRw5qxsZuakclZRDutGMGC4nvQ2ZqwREa5fXsgVZ0zjFy/to6NLubEk/hlpIonvR5xmrdf31XGirZPrlhdy48qZzMxJYc3Ww3xt9TaOtXSS6vOyenM11y6bwct7arhy8fQeNZmLF+TzrWd2sW5vDR92JnT87Zv76egKcauT5BYRrl06g/teKKO2qZ289GT+uOkg//H0TiC8rOzX3re4x+zBI2nj/mPsPNTIu07LozgvvsB7Kp58q4rKuha+9r5FfPuZXXxzzS5+8pHJMzzrWHMHm6uO89nL5wNw8YI8/vO5Pd2fCbdZwDCTVlpyEp8/hV5Yp0/PwO/18LMX9+H3elhelE12qo+f/HUvP/nrXublp1N2tIklhZk8/IlzmJmdyn+/XM6Dr1bQ0tHV3RwVsXB6BlMzknlpTw3LZ2Xzp83VPPRaJZctnNqjJ9Z7ls7gJ38t49nth1k5O4e7ntjKOcW5LJ2ZxQOvVNDc0cV3PrgM7wgGjQP1LXz7mV08HZWQn5ufxrvPmMbfX1BMYXbKsL1We7CLH68t48xZ2dx6QTHHWjr58dq9fPTcopiLak1Er5TVohr+IwPCP//zuT28sreWG1YMNOvS8LCAYUyCAj4vD3/iHEKqnFWUQ4o/3B324PFWHis9wAu7a7jrmoV88l1zumsSX7zqdD5+YTFvVtRzxRk9A4aIcNH8fJ54q4qntxzCI+FVBb/ynjN6nLdwegZz8tJ4fGMV/72unIxAEj/96Ary05NJT07iR2v3crylgwvm5ZHq95Li97JweiYLpqV3j5JvaOnk169X8vtNB7lkQT5fvPJ00pL7fg20dAR5eW8tL+4+yrz8dD5+4Zwegaits4sfr93LL1+pwCPw2cvn895lM3i1rJa1u47y4KsV/Oq1Sj518Vxuv3Qeqf6hf9U8uuEAB4+38q0PLEVE+PQl83hiYxX/tno7f/qnd8WVf+qtuT3I7zYc4KHXKvB5PfzXjWeyoqj/btXRQiHlmW2HqW1qx+f14E/yMC8/Le7rT8VLe2rISvFx5szwgl6LC7LISfWxbk/NiAQMmUhtnyUlJVpaWjraxTAmYW+/c4yf/rWMixfkc83S6UzNiD254/ee3cV9L+wjySP87lPnsXJ2bvex+9ft47t/3k2wV++hwuwULj9jKgGfl0fefIem9iDLZmaxpaqBwuwUvvH+JVyyIJ+9R5t4tayWV/bW8kpZLe3BECk+L62dXZTMzuEHNy1nVm4q6yvq+fITW6iobeYDKwr556sX9pmM8uDxVr79zC6e2lzN9MwA168owCtCSMHvDU+xclZRDlMzAwS7Qmw52MDr++o41NDKxfPzuWh+fncghnCAuvi7L1A8JY3ffeq87gD4zNZDfPq3b3H14unkZyQTDCk+r7CkMIuVs3OYm5fWY0qZjmCIitpm9h49waZ3jvNo6QEa24KUzM7hUEMbRxrb+PyVC7j94nm0Bbt4bvsRnt56iBlZAf7Ppad1/55HGtv4wqObeaWsb2eFW86fzd3vOSPmuJreDje08ZlH3iI3zc9nL5/PksJwc2copLy45yhPbT7Epafnc92Z4ZkOzv3mWs6Zk8tP//as7nv80/++zev76tjwL5fHPX1ObyKy0Zm3b+DzLGAYM37sPXKCG+57lbuuWcjHYgzYag920drRRWtnF83tQUorj7F211Fe2VtLW7CLa5fO4NOXzmNxQRallfXc9eRWyo42kZPq41hLJxBeXfDyhdO4ctE0zp6Ty9NbDvGvf9hGSJVLF07l6S2HmJWbwrc/sIwLnSV6+1NaWc9/PL2TbQcbEAFBCIZCRGJaYXYKDa2dNDkLXkUCVMDn4V2n5ZOb5qO1M0T18VY27j/G7247j3Ojmp9UlS8+toW/7DiM1yN4PR7aOru675ed6iMz4KM92EV7MMSJtmB3d2qvR7hq8TQ+edFczirKoaG1k688uZWntx5i4fQM3qlvoaWji+mZAeqa2/GI8Pfnz+aMGZnc+6cdtHeG+Nf3LuLqJdPpCIboCIZ4+PVKHnilgtOmpvOjm5ez2Ml3xVJ2tIlbHlzP8ZYOvB6hsS3IlYumcd7cKfz2zf3sq2kmOclDezDEVYun8XfnzeZjD6znux9a1p3rAnis9ABfenwLa+68iEXOjMqJsoBhzATVHuyKe2XDiMiXaO/EaHuwi1++XEHZ0SbOnZPLhaflMSvG1O5Vx1r4wqObWV9Zzy3nF/Olq2I3ZcVb/m0HG3n7nWNsOnCcrBQfF56Wx7lzcslM8fFmeT3P7TjMi7vDXZBT/F6Skzxccno+d19zxqD3D4WU8tomNu4P37+tM0RykofkJA8ZAR/zp6Uzf2oGc/PT+tQCVJVHSw/wwCsVrJydww3LCzm7OJeDx1v54fN7+f3bVYQUlhZm8aObl8cc7b9uTw1ffGwzdc0d5Kb5SfF5Cfg8FOWmccnp+Vy6IJ/apnY+/qsNJHk8/OrjZ1M0JZWHXqnkl6+Uc6ItyOKCTP7xorlcvWQ6v3qtku//ZQ+dXSFU4c2vXN5j8bIjjW2c+8213HXNQm6/pM+E3nGxgGGMGVahkFLb1M7UYV5pcTzZe+QEb71zjPevmBlzCvyI+uYOHnylgrrmdto6Q7R0BNlxqJED9eFuwB6BWbmp/PoT5/Tozt3Q2kn18VYWTs/o0by098gJvvzEFlL8Xn77yfP6vN5VP1hHfkYy//PJc0/p97KAYYwxY4iqUlHbzIu7a6g61sqnL51HfsbwdIXdffgEM7IDZAZ8p3R9vAHDekkZY8wIEBHm5qef8qSVAzl9ev/znw0nG+ltjDEmLhYwjDHGxMUChjHGmLhYwDDGGBMXCxjGGGPiYgHDGGNMXCxgGGOMiYsFDGOMMXGZUCO9RaQG2D+EW+QBfaefnLzs/ejJ3o++7D3paby+H7NVNX+wkyZUwBgqESmNZ3j8ZGHvR0/2fvRl70lPE/39sCYpY4wxcbGAYYwxJi4WMHq6f7QLMMbY+9GTvR992XvS04R+PyyHYYwxJi5WwzDGGBMXCxiAiFwtIrtFpExE7hrt8ow0EZklIi+IyE4R2S4in3X254rIX0Rkr/MzZ7TLOtJExCsib4vIn5ztOSLypvOe/E5E/KNdxpEiItki8riI7HI+K+dP9s+IiPxf5//MNhH5XxEJTOTPyKQPGCLiBe4DrgEWAR8RkUWjW6oRFwS+oKpnAOcBn3Heg7uAtao6H1jrbE82nwV2Rm1/B/iB854cA/5hVEo1On4E/FlVFwJnEn5fJu1nREQKgTuBElVdAniBm5nAn5FJHzCAc4AyVS1X1Q5gFXD9KJdpRKnqIVV9y3l+gvAXQSHh9+Fh57SHgRtGp4SjQ0RmAtcCv3S2BbgMeNw5ZdK8JyKSCVwMPACgqh2qepxJ/hkhvGppiogkAanAISbwZ8QCRviL8UDUdpWzb1ISkWJgBfAmME1VD0E4qABTR69ko+KHwD8DIWd7CnBcVYPO9mT6rMwFaoCHnCa6X4pIGpP4M6KqB4H/BN4hHCgagI1M4M+IBQyQGPsmZdcxEUkHngA+p6qNo12e0SQi7wWOqurG6N0xTp0sn5Uk4CzgZ6q6AmhmEjU/xeLka64H5gAFQBrhpu3eJsxnxAJG+C+AWVHbM4HqUSrLqBERH+Fg8VtVfdLZfUREZjjHZwBHR6t8o+BC4DoRqSTcTHkZ4RpHttP8AJPrs1IFVKnqm87244QDyGT+jFwBVKhqjap2Ak8CFzCBPyMWMGADMN/p2eAnnLRaPcplGlFO2/wDwE5V/X7UodXALc7zW4A/jnTZRouq3q2qM1W1mPBn4q+q+lHgBeBDzmmT5j1R1cPAARE53dl1ObCDSfwZIdwUdZ6IpDr/hyLvyYT9jNjAPUBE3kP4r0cv8KCqfmOUizSiRORdwMvAVk6213+FcB7jUaCI8H+OG1W1flQKOYpE5FLgi6r6XhGZS7jGkQu8DfydqraPZvlGiogsJ9wBwA+UAx8n/EfnpP2MiMjXgZsI9zR8G/gk4ZzFhPyMWMAwxhgTF2uSMsYYExcLGMYYY+JiAcMYY0xcLGAYY4yJiwUMY4wxcbGAYcwwEZHPiUjqaJfDGLdYt1pjhokzKrxEVWtHuyzGuMFqGMacAhFJE5GnRWSzsxbC1wjPJ/SCiLzgnHOliLwuIm+JyGPOXF2ISKWIfEdE1juP05z9Nzr32iwi60bvtzMmNgsYxpyaq4FqVT3TWQvhh4TnDPobVf0bEckDvgpcoapnAaXA56Oub1TVc4CfOtcC3ANcpapnAteN1C9iTLwsYBhzarYCVzg1hYtUtaHX8fMIL8j1qohsIjyn0Oyo4/8b9fN85/mrwK9E5B8JT1NjzJiSNPgpxpjeVHWPiKwE3gN8S0Se63WKAH9R1Y/0d4vez1X1dhE5l/CiTZtEZLmq1g132Y05VVbDMOYUiEgB0KKq/0N4EZ2zgBNAhnPKG8CFUfmJVBFZEHWLm6J+vu6cM09V31TVe4Baek67b8yosxqGMadmKfA9EQkBncCnCTctPSMih5w8xq3A/4pIsnPNV4E9zvNkEXmT8B9tkVrI90RkPuHayVpg88j8KsbEx7rVGjPCrPutGa+sScoYY0xcrIZhjDEmLlbDMMYYExcLGMYYY+JiAcMYY0xcLGAYY4yJiwUMY4wxcbGAYYwxJi7/H4g938Q/ByNYAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#可视化\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.plot(range(len(loss_mat)), loss_mat) \n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('steps_entropy_loss')\n",
    "plt.show() \n",
    "\n",
    "plt.plot(range(len(l2_loss_mat)), l2_loss_mat) \n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('steps_l2_loss')\n",
    "plt.show()\n",
    "\n",
    "plt.plot(range(len(total_loss_mat)), total_loss_mat) \n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('steps_total_loss')\n",
    "plt.show()\n",
    "\n",
    "plt.plot(range(len(acc_train_mat)), acc_train_mat, label='Train Accuracy') \n",
    "plt.plot(range(len(acc_test_mat)), acc_test_mat, label='Test Accuracy')\n",
    "plt.legend()\n",
    "plt.xlabel('steps')\n",
    "plt.ylabel('accuracy')\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "毫无疑问，这个模型是一个非常简陋，性能也不理想的模型。目前只能达到92%左右的准确率。\n",
    "接下来，希望大家利用现有的知识，将这个模型优化至98%以上的准确率。\n",
    "Hint：\n",
    "- 卷积\n",
    "- 池化\n",
    "- 激活函数\n",
    "- 正则化\n",
    "- 初始化\n",
    "- 摸索一下各个超参数\n",
    "  - 卷积kernel size\n",
    "  - 卷积kernel 数量\n",
    "  - 学习率\n",
    "  - 正则化惩罚因子\n",
    "  - 最好每隔几个step就对loss、accuracy等等进行一次输出，这样才能有根据地进行调整"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
